#include <iostream>
using namespace std;


//class A
//{
//  public:
//   A(int a,int b)
//      :_a(a)
//    {
//      cout<<"A(int a=0)"<<endl;
//    }
//
//  private:
//    int _a;
//};
//
//class  Date
//{
//  public:
//    //初始化列表
// //   Date(int year,int month,int day)
// //   :_year(year)
// //   ,_month(month)
// //   ,_day(day)
// //   {}
//
//   // Date(int year,int month,int day)
//   //  :_n(1)//初始化列表是每个成员变量定义初始化的位置
//   //  ,_month(2)
//   // {
//   //   //赋值修改
//   //   _year=year;
//   //   _month=month;
//   //   _day=day;
//   // }
//
//  //private:
//   // //声明
//   // int _year=1;//缺省值
//   // int _month=1;
//   // int _day;
//
//   // const int _n;//在定义的时候初始化
//   // };
//   //
//   //
//   
//  Date(int year,int month,int day,int &x)
//     :_year(year)
//     ,_month(month)
//     ,_day(day)
//     ,_n(1)
//     ,_ref(x)
//     ,_aa(1,2)
//      ,_p((int*)malloc(sizeof(4)))
//    {
//       if(_p==nullptr)
//       {
//         perror("malloc fail");
//       }
//    }
//
//  private:
//    //声明
//    int _year=1;//缺省值
//    int _month=1;
//    int _day;
//
//    //必须走初始化
//    const int _n;
//    int & _ref;
//    A _aa;
//    
//    int*_p;
//    };
//   
//int main()
//{
//
//  int x=10;
//  Date d1(2024,1,31,x); 
//  return 0;
//}
//
//

//
//class C
//{
//  public:
// // explicit   C(int x=0)//如果不想让隐式类型的转换发生，就加一个关键字explicit
//   C(int x=0)
//      :_x(x)
//    {}
//
//  private:
//    int _x;
//};
//
//
//class B
//{
//
//  private:
//    //缺省值   是给初始化列表的
//    //
//    int a=1;
//    int *p1=nullptr;
//    int *p2=(int*)malloc(4);
//};
//
//
//int main()
//{
//  B bb;
//  C cc1(1);
//  //单参数构造函数支持隐式类型的转换
//  //2 构造一个零时对象，在拷贝构造
//  C cc2 = 2;//
//  
//  const C&cc3=2;//cc3引用的是零时变量，临时变量具有常性
//
//  return 0;
//}
//
//


//class A
//{
//  public:
//    A(int a1,int a2)
////   explicit  A(int a1,int a2)
//      :_a1(a1)
//       ,_a2(a2)
//    {
//
//    }
//
//  private:
//    int _a1;
//    int _a2;
//};
//
//int main()
//{
//
// // A aa1=1,2;//c++11支持多参数
// //
// A aa1={1,2};
// const A& aa2={1,2};
//  return 0;
//}
//
//
//



///class A
///{
///public:
///	A(int a)
///		:_a1(a)
///		, _a2(2)
///	{}
///
///	void Print() {
///		cout << _a1 << " " << _a2 << endl;
///	}
///private:
///	// 声明顺序
///	int _a2;
///	int _a1;
///};
///
/////// A.输出1 1
/////// B.程序崩溃
/////// C.编译不通过
/////// D.输出1 随机值
///
/////声明的顺序和初始化列表的顺序保持一致
///int main() {
///	A aa(1);
///	aa.Print();
///}






ass A
{
public:
	A()
	{
		++n;
	}

	A(const A& aa)
	{
		++n;
	}

	// static成员函数没有this指针
	static int GetN()
	{
		//a++;
		return n;
	}

//private:
//静态的不可以给缺省值
  // 不是属于某一个对象，属于所有对象，属于整个类
	// 声明
	static int n;

	int a = 0;
};

// 定义
int A::n = 0;

A Func()
{
	A aa;

	return aa;
}

int main()
{
	A aa1;
	A aa2;
	A* ptr = nullptr;
	Func();

	//cout << aa1.n << endl;
	//cout << aa2.n << endl;
	//cout << ptr->n << endl;
	//cout << A::n << endl;
	//cout << aa1.GetN() << endl;
	cout << A::GetN() << endl;


	return 0;
}
